Inputs and outputs are always the exactly the same structure...
... regardless of map format.
Requesting tile data from Map2 will output the data...
... in exactly the same form as requesting from Map3.



#						data.get.tileSize()

#						data.get.width()								(in tiles)

#						data.get.height()								(in tiles)

#						data.get.tileChipIndex( location )
							location:	{ layer, x, y }

#						data.get.chipsetQuantity()

#						data.get.maxChipsetQuantity()

{width,height}		data.get.maxChipsetSize();		(in tiles)

tileData		data.get.tile( location )
							location:	{ layer, x, y }
							tileData:		{ chipset, x, y }		(Always returns this, even when accessing Map2)

#						data.get.layerQuantity()

""						data.get.chipsetFile( chipsetIndex )
							"chipset's image filePath"

[chipsetData]	data.get.allChipsets()
								[array of filePaths]		(always returns an array, even when editing Map2)

mapData			data.get.data()

#						data.get.collisionTile( location )
							location:	{ x, y }
							#  Returns the collisionValue stored in that location of the map



-						data.set.tileSize( newTileSize )

-						data.set.width( newWidth )

-						data.set.height( newHeight )

-						data.set.chipsetFile( chipsetIndex, filePath )

-						data.set.allChipsets( [chipsetData] )
							Always requires an array of filePaths, even when editing Map2

-						data.set.tile( location, tileData )
							location:	{ layer, x, y }
							tileData:		{ chipset, x, y }		(Always requires this data, even when editing Map2)

-						data.set.tileChipIndex( location, newChipIndex )
							location:	{ layer, x, y }

-						data.set.data( mapData )

-						data.set.collisionTile( location, collisionID )
							location:	{ x, y }



-						data.add.chipset( chipFilePath )

-						data.add.layer( layer, tile )
							tile:  {chipset, x, y}



-						data.remove.chipset( chipIndex )

-						data.remove.layer( layerIndex )



-						data.modify.shiftTilesHorz( xOffset )
-						data.modify.shiftTilesVert( yOffset )

-						data.modify.wrapTilesHorz( xOffset )
-						data.modify.wrapTilesVert( yOffset )



tileData			data.create.blankTile()

tileData			data.create.tileFromChipset( xChip, yChip, chipsetIndex )

un-compressedMapData				data.create.map( width, height, tileSize, format )
																width, height, tileSize, format  are all optional

compressedMapData						data.create.compressedMap( uncompressedMapData )

un-compressedMapData				data.create.uncompressedMap( compressedMapData )

compressedCollisionStr			data.create.compressedCollision( uncompressedCollision_ary, tileWidth, tileHeight )

uncompressedCollisionAry		data.create.uncompressedCollision( compressedCollision_str, tileWidth, tileHeight )

collisionValue							data.create.blankCollisionValue()



tileData			data.copy.tile( tileData )



Check data from .change() reactions...
... and wrap map data into temporary collections
	myObj.reactTo( data.any ).change = function(){}
	myObj.reactTo( data.chipsets ).change = function(){}